// 智能识别页面结构
export const autoDetectPageStructure = () => {
  console.log('开始智能识别页面结构...')

  // 常见的列表容器选择器 - 按优先级排序，优先特定的内容区域
  const listSelectors = [
    '.sec_list li',    // 特定的列表类 - 优先级最高
    '.content li',     // 内容区域的列表
    '.main li',        // 主要内容区域
    '.list li',        // 通用列表类
    '.item',           // 项目类
    '.article',        // 文章类
    '.news-item',      // 新闻项目
    '.content-item',   // 内容项目
    '.post',           // 帖子
    '.entry',          // 条目
    'ul li',           // 通用ul li - 优先级降低
    'ol li',           // 有序列表
    'tr',              // 表格行
    '.row',            // 行
    '.card',           // 卡片
    '[class*="list"] li',
    '[class*="item"]',
    '[id*="list"] li'
  ]

  // 常见的标题选择器
  const titleSelectors = [
    'h1', 'h2', 'h3', 'h4', 'h5', 'h6', '.title', '.headline',
    '.subject', '.name', 'a[title]', '[class*="title"]', '[class*="name"]'
  ]

  // 常见的链接选择器
  const linkSelectors = ['a[href]', '.link', '[class*="link"]']

  // 常见的日期选择器
  const dateSelectors = [
    'i.date',          // 特定的i标签日期
    '.date',
    '.time',
    '.datetime',
    '.publish',
    '.created',
    '[class*="date"]',
    '[class*="time"]',
    'time',
    '.meta',
    'i[class*="date"]',
    'span.date'
  ]

  // 常见的下一页选择器
  const nextPageSelectors = [
    '.next', '.next-page', '.page-next', 'a[title*="下一页"]',
    'a[title*="next"]', '.pagination .next', '.pager .next',
    'a:contains("下一页")', 'a:contains(">")', 'a:contains("»")'
  ]

  let bestConfig = {
    listSelector: '',
    titleSelector: '',
    titleLinkSelector: '',
    dateSelector: '',
    nextPageSelector: ''
  }

  // 检测列表结构 - 改进逻辑
  let maxItems = 0
  let bestListSelector = ''

  for (const selector of listSelectors) {
    try {
      const items = document.querySelectorAll(selector)
      console.log(`测试选择器 "${selector}": 找到 ${items.length} 个项目`)

      if (items.length >= 3) { // 至少3个项目才认为是列表
        // 检查这些项目是否包含有效的内容链接
        let hasValidLinks = 0
        let hasValidContent = 0

        for (let i = 0; i < Math.min(items.length, 5); i++) {
          const item = items[i]
          const link = item.querySelector('a[href]')

          if (link) {
            const href = link.getAttribute('href') || ''
            const text = link.textContent?.trim() || ''

            // 检查是否是有效的内容链接（不是导航、菜单等）
            const isValidLink = href &&
              !href.includes('#') &&  // 不是锚点链接
              !href.includes('javascript:') && // 不是JS链接
              text.length > 10 && // 链接文本足够长
              !text.match(/^(首页|导航|菜单|登录|注册|搜索|English|中文)$/i) // 不是常见的导航文本

            if (isValidLink) {
              hasValidLinks++
            }

            // 检查是否有日期信息（内容列表通常有日期）
            if (item.querySelector('.date, i.date, .time, [class*="date"], [class*="time"]')) {
              hasValidContent++
            }
          }
        }

        const checkCount = Math.min(items.length, 5)
        const linkRatio = hasValidLinks / checkCount
        const contentRatio = hasValidContent / checkCount

        // 综合评分：有效链接比例 + 内容比例，优先选择内容丰富的列表
        const score = linkRatio * 0.7 + contentRatio * 0.3

        console.log(`选择器 "${selector}": ${items.length} 项目, 有效链接: ${hasValidLinks}/${checkCount}, 内容: ${hasValidContent}/${checkCount}, 评分: ${score.toFixed(2)}`)

        // 优先选择评分高的，如果评分相近则选择项目数量适中的（避免选择过多的导航项目）
        const currentBestScore = bestListSelector ? 0.6 : 0
        const shouldSelect = score >= 0.4 && (
          score > currentBestScore ||
          (score >= currentBestScore * 0.8 && items.length < maxItems && items.length >= 10)
        )

        if (shouldSelect) {
          maxItems = items.length
          bestListSelector = selector
          console.log(`✓ 选择更好的列表选择器: "${selector}", 评分: ${score.toFixed(2)}, 项目数: ${items.length}`)
        }
      }
    } catch (e) {
      console.log(`选择器 "${selector}" 无效:`, e.message)
    }
  }

  bestConfig.listSelector = bestListSelector

  // 如果找到了列表容器，在容器内查找其他元素
  if (bestConfig.listSelector) {
    const listItems = document.querySelectorAll(bestConfig.listSelector)
    console.log(`使用列表选择器 "${bestConfig.listSelector}" 找到 ${listItems.length} 个项目`)

    if (listItems.length > 0) {
      const firstItem = listItems[0]
      console.log('分析第一个列表项:', firstItem)

      // 在第一个列表项内查找标题
      for (const selector of titleSelectors) {
        try {
          const titleEl = firstItem.querySelector(selector)
          if (titleEl && titleEl.textContent.trim()) {
            bestConfig.titleSelector = selector
            console.log(`找到标题选择器: "${selector}", 内容: "${titleEl.textContent.trim().substring(0, 50)}..."`)
            break
          }
        } catch (e) {}
      }

      // 在第一个列表项内查找链接
      for (const selector of linkSelectors) {
        try {
          const linkEl = firstItem.querySelector(selector)
          if (linkEl && linkEl.href) {
            bestConfig.titleLinkSelector = selector
            console.log(`找到链接选择器: "${selector}", 链接: "${linkEl.href}"`)
            break
          }
        } catch (e) {}
      }

      // 在第一个列表项内查找日期
      for (const selector of dateSelectors) {
        try {
          const dateEl = firstItem.querySelector(selector)
          if (dateEl && dateEl.textContent.trim()) {
            bestConfig.dateSelector = selector
            console.log(`找到日期选择器: "${selector}", 日期: "${dateEl.textContent.trim()}"`)
            break
          }
        } catch (e) {}
      }
    }
  } else {
    // 如果没有找到列表容器，直接查找页面级别的元素
    for (const selector of titleSelectors) {
      try {
        const titles = document.querySelectorAll(selector)
        if (titles.length >= 3) {
          bestConfig.titleSelector = selector
          break
        }
      } catch (e) {}
    }

    for (const selector of linkSelectors) {
      try {
        const links = document.querySelectorAll(selector)
        if (links.length >= 3) {
          bestConfig.titleLinkSelector = selector
          break
        }
      } catch (e) {}
    }
  }

  // 查找下一页按钮
  for (const selector of nextPageSelectors) {
    try {
      const nextEl = document.querySelector(selector)
      if (nextEl) {
        bestConfig.nextPageSelector = selector
        break
      }
    } catch (e) {}
  }

  console.log('智能识别结果:', bestConfig)
  return bestConfig
}



// 爬虫功能模块
export const crawlPage = (config) => {
  console.log('开始爬取，配置:', config)

  // 获取当前页面的基础URL，用于处理相对链接
  const baseUrl = window.location.origin

  // 处理相对链接的函数
  const resolveUrl = (url) => {
    if (!url) return ''
    if (url.startsWith('http://') || url.startsWith('https://')) {
      return url // 绝对链接
    }
    if (url.startsWith('//')) {
      return window.location.protocol + url // 协议相对链接
    }
    if (url.startsWith('/')) {
      return baseUrl + url // 根相对链接
    }
    return baseUrl + '/' + url // 相对链接
  }

  // 过滤无效内容的函数
  const isValidContent = (title, link) => {
    if (!title || !link) return false

    // 过滤分页导航
    const navigationTexts = ['首页', '上一页', '下一页', '尾页', '末页', '第一页', '最后一页']
    if (navigationTexts.some(nav => title.trim() === nav)) {
      return false
    }

    // 过滤太短的标题
    if (title.trim().length < 5) {
      return false
    }

    // 过滤明显的导航链接
    if (link.includes('#') || link.includes('javascript:')) {
      return false
    }

    return true
  }

  // 简化逻辑：直接获取所有匹配的元素
  const results = []

  // 如果有列表选择器，按列表项处理
  if (config.listSelector) {
    const listItems = document.querySelectorAll(config.listSelector)
    console.log(`通过列表选择器找到 ${listItems.length} 个项目`)

    listItems.forEach((item, index) => {
      const result = {}

      // 在每个列表项内查找内容 - 优化逻辑
      if (config.titleSelector) {
        // 优先使用 querySelector 而不是 querySelectorAll，更精确
        const titleEl = item.querySelector(config.titleSelector)
        if (titleEl && titleEl.textContent?.trim()) {
          result.title = titleEl.textContent.trim()
          console.log(`第 ${index + 1} 项标题: ${result.title.substring(0, 50)}...`)
        }
      }

      if (config.titleLinkSelector) {
        const linkEl = item.querySelector(config.titleLinkSelector)
        if (linkEl) {
          const rawUrl = linkEl.href || linkEl.getAttribute('href') || ''
          if (rawUrl) {
            result.titleLink = resolveUrl(rawUrl)
            console.log(`第 ${index + 1} 项链接: ${result.titleLink}`)
          }
        }
      }

      if (config.dateSelector) {
        const dateEl = item.querySelector(config.dateSelector)
        if (dateEl && dateEl.textContent?.trim()) {
          result.date = dateEl.textContent.trim()
          console.log(`第 ${index + 1} 项日期: ${result.date}`)
        }
      }

      // 自定义字段
      if (config.customSelectors && Array.isArray(config.customSelectors)) {
        config.customSelectors.forEach(selector => {
          if (selector.name && selector.value) {
            const els = item.querySelectorAll(selector.value)
            console.log(`在第 ${index + 1} 个项目中通过自定义选择器找到 ${els.length} 个元素`)
            if (els.length > 0) {
              for (let i = 0; i < els.length; i++) {
                const el = els[i]
                if (el.textContent?.trim()) {
                  result[selector.name] = el.textContent?.trim() || ''
                  break
                }
              }
            }
          }
        })
      }

      // 只有当结果包含有效数据且通过过滤时才添加
      if (Object.keys(result).length > 0 && Object.values(result).some(val => val)) {
        // 使用过滤函数检查内容有效性
        if (isValidContent(result.title, result.titleLink)) {
          results.push(result)
        } else {
          console.log(`过滤掉无效内容: ${result.title}`)
        }
      }
    })
  } else {
    // 如果没有列表选择器，直接获取所有匹配的元素
    console.log('没有列表选择器，直接获取所有匹配元素')

    const titleElements = config.titleSelector ? document.querySelectorAll(config.titleSelector) : []
    const linkElements = config.titleLinkSelector ? document.querySelectorAll(config.titleLinkSelector) : []
    const dateElements = config.dateSelector ? document.querySelectorAll(config.dateSelector) : []

    // 获取自定义选择器的元素
    const customElements = {}
    if (config.customSelectors && Array.isArray(config.customSelectors)) {
      config.customSelectors.forEach(selector => {
        if (selector.name && selector.value) {
          customElements[selector.name] = document.querySelectorAll(selector.value)
        }
      })
    }

    // 计算最大长度，包括自定义选择器
    const allLengths = [
      titleElements.length,
      linkElements.length,
      dateElements.length,
      ...Object.values(customElements).map(els => els.length)
    ]
    const maxLength = Math.max(...allLengths, 0)
    console.log(`找到 ${maxLength} 个数据项`)

    for (let i = 0; i < maxLength; i++) {
      const result = {}

      if (titleElements[i]) {
        result.title = titleElements[i].textContent?.trim() || ''
      }

      if (linkElements[i]) {
        const rawUrl = linkElements[i].href || linkElements[i].getAttribute('href') || ''
        result.titleLink = resolveUrl(rawUrl)
      }

      if (dateElements[i]) {
        result.date = dateElements[i].textContent?.trim() || ''
      }

      // 处理自定义字段
      Object.keys(customElements).forEach(fieldName => {
        if (customElements[fieldName][i]) {
          result[fieldName] = customElements[fieldName][i].textContent?.trim() || ''
        }
      })

      // 只有当结果包含有效数据且通过过滤时才添加
      if (Object.keys(result).length > 0 && Object.values(result).some(val => val)) {
        if (isValidContent(result.title, result.titleLink)) {
          results.push(result)
        }
      }
    }
  }

  console.log(`本页爬取完成，共获得 ${results.length} 条有效数据`)

  // 获取下一页链接
  let nextPageUrl = null
  if (config.nextPageSelector) {
    const nextPageEl = document.querySelector(config.nextPageSelector)
    if (nextPageEl) {
      nextPageUrl = nextPageEl.href || nextPageEl.getAttribute('href')
      if (nextPageUrl) {
        nextPageUrl = resolveUrl(nextPageUrl)
      }
    }
  }

  return {
    items: results,
    nextPage: nextPageUrl,
    pageInfo: {
      totalItems: results.length,
      hasListSelector: !!config.listSelector,
      selectors: {
        list: config.listSelector || '',
        title: config.titleSelector || '',
        titleLink: config.titleLinkSelector || '',
        date: config.dateSelector || '',
        nextPage: config.nextPageSelector || '',
        custom: config.customSelectors || []
      }
    }
  }
}

// 执行多页爬取
export const executeCrawl = async (config) => {
  try {
    const [tab] = await chrome.tabs.query({ active: true, currentWindow: true })
    let allResults = []
    let currentPage = 1
    let hasNextPage = true

    console.log(`开始多页爬取，最大页数: ${config.maxPages}`)

    while (currentPage <= config.maxPages && hasNextPage) {
      console.log(`正在爬取第 ${currentPage} 页...`)

      // 爬取当前页面
      const result = await chrome.scripting.executeScript({
        target: { tabId: tab.id },
        func: crawlPage,
        args: [config]
      })

      const pageResult = result[0].result
      console.log(`第 ${currentPage} 页爬取完成，获得 ${pageResult.items.length} 条数据`)

      // 合并结果
      allResults = allResults.concat(pageResult.items)

      // 检查是否有下一页
      if (pageResult.nextPage && currentPage < config.maxPages) {
        console.log(`发现下一页链接: ${pageResult.nextPage}`)

        // 智能翻页：先尝试点击，再尝试直接跳转
        const navigated = await chrome.scripting.executeScript({
          target: { tabId: tab.id },
          func: (nextPageSelector, nextPageUrl) => {
            // 方法1：尝试点击下一页按钮
            const nextBtn = document.querySelector(nextPageSelector)
            if (nextBtn) {
              // 检查是否是链接或按钮
              if (nextBtn.tagName === 'A' || nextBtn.tagName === 'BUTTON' || nextBtn.onclick) {
                nextBtn.click()
                return { method: 'click', success: true }
              }
            }

            // 方法2：如果有下一页URL，直接跳转
            if (nextPageUrl) {
              window.location.href = nextPageUrl
              return { method: 'navigate', success: true }
            }

            return { method: 'none', success: false }
          },
          args: [config.nextPageSelector, pageResult.nextPage]
        })

        const navResult = navigated[0].result
        if (navResult.success) {
          console.log(`使用 ${navResult.method} 方法翻页成功`)
          // 根据翻页方法调整等待时间
          const waitTime = navResult.method === 'navigate' ? 3000 : 2000
          await new Promise(resolve => setTimeout(resolve, waitTime))
          currentPage++
        } else {
          console.log('无法翻页，停止爬取')
          hasNextPage = false
        }
      } else {
        hasNextPage = false
      }
    }

    console.log(`爬取完成，共 ${currentPage} 页，总计 ${allResults.length} 条数据`)

    return {
      items: allResults,
      totalPages: currentPage,
      totalItems: allResults.length
    }
  } catch (error) {
    console.error('爬取失败:', error)
    throw error
  }
}
